// $ANTLR 3.0.1 C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g 2008-03-19 21:04:46

using System.Text;
using System.Collections.Generic;
using TextFlow.Engine;


using System;
using Antlr.Runtime;
using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;

using IDictionary	= System.Collections.IDictionary;
using Hashtable 	= System.Collections.Hashtable;


public class TextFlowLangParser : Parser 
{
    public static readonly string[] tokenNames = new string[] 
	{
        "<invalid>", 
		"<EOR>", 
		"<DOWN>", 
		"<UP>", 
		"STRING", 
		"DECIMAL", 
		"ID", 
		"FLOAT", 
		"CHAR", 
		"LPAREN", 
		"RPAREN", 
		"ESCAPE", 
		"WS", 
		"LETTER", 
		"DIGIT", 
		"COMMENT", 
		"LINE_COMMENT", 
		"'TXN'", 
		"'ENDTXN'", 
		"'AUTOTXN'", 
		"'ENDAUTOTXN'", 
		"'UNDO'", 
		"'ENDUNDO'", 
		"'ONERROR'", 
		"'ENDERROR'", 
		"'STOP'", 
		"'ERROR'", 
		"'WAITFOR'", 
		"'SECONDS'", 
		"'MINUTES'", 
		"'REPEAT'", 
		"'TIMES'", 
		"'ENDREPEAT'", 
		"'IF'", 
		"'THEN'", 
		"'ELSEIF'", 
		"'ELSE'", 
		"'ENDIF'", 
		"'WHILE'", 
		"'ENDWHILE'", 
		"'INPARALLEL'", 
		"'START'", 
		"'END'", 
		"'ENDPARALLEL'", 
		"'SET'", 
		"'='", 
		"'['", 
		"']'", 
		"'=>'", 
		"'TRUE'", 
		"'FALSE'", 
		"'NULL'", 
		"'OR'", 
		"'AND'", 
		"'NOT'", 
		"'=='", 
		"'!='", 
		"'<='", 
		"'>='", 
		"'<'", 
		"'>'", 
		"'+'", 
		"'-'", 
		"'*'", 
		"'/'", 
		"'.'", 
		"'()'", 
		"','"
    };

    public const int RPAREN = 10;
    public const int WS = 12;
    public const int ESCAPE = 11;
    public const int DECIMAL = 5;
    public const int LINE_COMMENT = 16;
    public const int LETTER = 13;
    public const int CHAR = 8;
    public const int FLOAT = 7;
    public const int DIGIT = 14;
    public const int COMMENT = 15;
    public const int ID = 6;
    public const int EOF = -1;
    public const int LPAREN = 9;
    public const int STRING = 4;
    
    
        public TextFlowLangParser(ITokenStream input) 
    		: base(input)
    	{
    		InitializeCyclicDFAs();
            ruleMemo = new IDictionary[80+1];
         }
        

    override public string[] TokenNames
	{
		get { return tokenNames; }
	}

    override public string GrammarFileName
	{
		get { return "C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g"; }
	}

    
    
    private StringBuilder _errors = new StringBuilder();
    
    public bool HasErrors
    {
       get { return _errors.Length > 0; }
    }
    
    public string Errors
    {
       get { return _errors.ToString(); }
    }
    
    public override void EmitErrorMessage( string msg )
    {
       _errors.AppendLine( msg );
    }
    
    public event EventHandler<TextFlowEventArgs> ProgStart;
    public event EventHandler<TextFlowEventArgs> ProgEnd;
    public event EventHandler<TextFlowEventArgs> ParallelStart;
    public event EventHandler<TextFlowEventArgs> ParallelEnd;
    public event EventHandler<TextFlowEventArgs> ParallelChildStart;
    public event EventHandler<TextFlowEventArgs> ParallelChildEnd;
    public event EventHandler<TextFlowEventArgs> WhileStart;
    public event EventHandler<TextFlowEventArgs> WhileEnd;
    public event EventHandler<TextFlowEventArgs> IterationStart;
    public event EventHandler<TextFlowEventArgs> IterationEnd;
    public event EventHandler<TextFlowEventArgs> IfStart;
    public event EventHandler<TextFlowEventArgs> ElseIfClause;
    public event EventHandler<TextFlowEventArgs> ElseClause;
    public event EventHandler<TextFlowEventArgs> IfEnd;
    public event EventHandler<TextFlowEventArgs> Assign;
    public event EventHandler<TextFlowEventArgs> Condition;
    public event EventHandler<TextFlowEventArgs> Action;
    public event EventHandler<TextFlowEventArgs> PostAction;
    public event EventHandler<TextFlowEventArgs> ActionInput;
    public event EventHandler<TextFlowEventArgs> ActionOutput;
    public event EventHandler<TextFlowEventArgs> Compare;
    public event EventHandler<TextFlowEventArgs> Literal;
    public event EventHandler<TextFlowEventArgs> Math;
    public event EventHandler<TextFlowEventArgs> Lookup;
    public event EventHandler<TextFlowEventArgs> Delay;
    public event EventHandler<TextFlowEventArgs> Method;
    public event EventHandler<TextFlowEventArgs> Property;
    public event EventHandler<TextFlowEventArgs> Error;
    public event EventHandler<TextFlowEventArgs> Stop;
    public event EventHandler<TextFlowEventArgs> OnErrorStart;
    public event EventHandler<TextFlowEventArgs> OnErrorEnd;
    public event EventHandler<TextFlowEventArgs> TxnStart;
    public event EventHandler<TextFlowEventArgs> TxnEnd;
    public event EventHandler<TextFlowEventArgs> RollbackStart;
    public event EventHandler<TextFlowEventArgs> RollbackEnd;


    
    // $ANTLR start prog
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:75:1: prog : ( stmt )+ ;
    public void prog() // throws RecognitionException [1]
    {   
        int prog_StartIndex = input.Index();
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 1) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:76:2: ( ( stmt )+ )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:76:4: ( stmt )+
            {
            	if ( backtracking == 0 ) 
            	{
            	   ProgStart( this, new TextFlowEventArgs() ); 
            	}
            	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:76:52: ( stmt )+
            	int cnt1 = 0;
            	do 
            	{
            	    int alt1 = 2;
            	    int LA1_0 = input.LA(1);
            	    
            	    if ( (LA1_0 == 17 || LA1_0 == 19 || LA1_0 == 23 || (LA1_0 >= 25 && LA1_0 <= 27) || LA1_0 == 30 || LA1_0 == 33 || LA1_0 == 38 || LA1_0 == 40 || LA1_0 == 44 || LA1_0 == 46) )
            	    {
            	        alt1 = 1;
            	    }
            	    
            	
            	    switch (alt1) 
            		{
            			case 1 :
            			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:76:54: stmt
            			    {
            			    	PushFollow(FOLLOW_stmt_in_prog56);
            			    	stmt();
            			    	followingStackPointer_--;
            			    	if (failed) return ;
            			    
            			    }
            			    break;
            	
            			default:
            			    if ( cnt1 >= 1 ) goto loop1;
            			    if ( backtracking > 0 ) {failed = true; return ;}
            		            EarlyExitException eee =
            		                new EarlyExitException(1, input);
            		            throw eee;
            	    }
            	    cnt1++;
            	} while (true);
            	
            	loop1:
            		;	// Stops C# compiler whinging that label 'loop1' has no statements

            	if ( backtracking == 0 ) 
            	{
            	   ProgEnd( this, new TextFlowEventArgs() ); 
            	}
            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 1, prog_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end prog

    
    // $ANTLR start stmt
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:79:1: stmt : ( ifstmt | whilestmt | parallelstmt | delaystmt | errorstmt | handleerrorstmt | iterationstmt | txnstmt | stopstmt | assignmentstmt | actionstmt );
    public void stmt() // throws RecognitionException [1]
    {   
        int stmt_StartIndex = input.Index();
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 2) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:80:2: ( ifstmt | whilestmt | parallelstmt | delaystmt | errorstmt | handleerrorstmt | iterationstmt | txnstmt | stopstmt | assignmentstmt | actionstmt )
            int alt2 = 11;
            switch ( input.LA(1) ) 
            {
            case 33:
            	{
                alt2 = 1;
                }
                break;
            case 38:
            	{
                alt2 = 2;
                }
                break;
            case 40:
            	{
                alt2 = 3;
                }
                break;
            case 27:
            	{
                alt2 = 4;
                }
                break;
            case 26:
            	{
                alt2 = 5;
                }
                break;
            case 23:
            	{
                alt2 = 6;
                }
                break;
            case 30:
            	{
                alt2 = 7;
                }
                break;
            case 17:
            case 19:
            	{
                alt2 = 8;
                }
                break;
            case 25:
            	{
                alt2 = 9;
                }
                break;
            case 44:
            	{
                alt2 = 10;
                }
                break;
            case 46:
            	{
                alt2 = 11;
                }
                break;
            	default:
            	    if ( backtracking > 0 ) {failed = true; return ;}
            	    NoViableAltException nvae_d2s0 =
            	        new NoViableAltException("79:1: stmt : ( ifstmt | whilestmt | parallelstmt | delaystmt | errorstmt | handleerrorstmt | iterationstmt | txnstmt | stopstmt | assignmentstmt | actionstmt );", 2, 0, input);
            
            	    throw nvae_d2s0;
            }
            
            switch (alt2) 
            {
                case 1 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:80:4: ifstmt
                    {
                    	PushFollow(FOLLOW_ifstmt_in_stmt73);
                    	ifstmt();
                    	followingStackPointer_--;
                    	if (failed) return ;
                    
                    }
                    break;
                case 2 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:81:8: whilestmt
                    {
                    	PushFollow(FOLLOW_whilestmt_in_stmt82);
                    	whilestmt();
                    	followingStackPointer_--;
                    	if (failed) return ;
                    
                    }
                    break;
                case 3 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:82:8: parallelstmt
                    {
                    	PushFollow(FOLLOW_parallelstmt_in_stmt91);
                    	parallelstmt();
                    	followingStackPointer_--;
                    	if (failed) return ;
                    
                    }
                    break;
                case 4 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:83:8: delaystmt
                    {
                    	PushFollow(FOLLOW_delaystmt_in_stmt100);
                    	delaystmt();
                    	followingStackPointer_--;
                    	if (failed) return ;
                    
                    }
                    break;
                case 5 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:84:8: errorstmt
                    {
                    	PushFollow(FOLLOW_errorstmt_in_stmt109);
                    	errorstmt();
                    	followingStackPointer_--;
                    	if (failed) return ;
                    
                    }
                    break;
                case 6 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:85:8: handleerrorstmt
                    {
                    	PushFollow(FOLLOW_handleerrorstmt_in_stmt118);
                    	handleerrorstmt();
                    	followingStackPointer_--;
                    	if (failed) return ;
                    
                    }
                    break;
                case 7 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:86:8: iterationstmt
                    {
                    	PushFollow(FOLLOW_iterationstmt_in_stmt127);
                    	iterationstmt();
                    	followingStackPointer_--;
                    	if (failed) return ;
                    
                    }
                    break;
                case 8 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:87:8: txnstmt
                    {
                    	PushFollow(FOLLOW_txnstmt_in_stmt136);
                    	txnstmt();
                    	followingStackPointer_--;
                    	if (failed) return ;
                    
                    }
                    break;
                case 9 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:88:8: stopstmt
                    {
                    	PushFollow(FOLLOW_stopstmt_in_stmt145);
                    	stopstmt();
                    	followingStackPointer_--;
                    	if (failed) return ;
                    
                    }
                    break;
                case 10 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:89:4: assignmentstmt
                    {
                    	PushFollow(FOLLOW_assignmentstmt_in_stmt150);
                    	assignmentstmt();
                    	followingStackPointer_--;
                    	if (failed) return ;
                    
                    }
                    break;
                case 11 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:90:4: actionstmt
                    {
                    	PushFollow(FOLLOW_actionstmt_in_stmt155);
                    	actionstmt();
                    	followingStackPointer_--;
                    	if (failed) return ;
                    
                    }
                    break;
            
            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 2, stmt_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end stmt

    
    // $ANTLR start txnstmt
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:93:1: txnstmt : ( 'TXN' ( stmt )* rollbackstmt 'ENDTXN' | 'AUTOTXN' ( stmt )* rollbackstmt 'ENDAUTOTXN' );
    public void txnstmt() // throws RecognitionException [1]
    {   
        int txnstmt_StartIndex = input.Index();
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 3) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:94:2: ( 'TXN' ( stmt )* rollbackstmt 'ENDTXN' | 'AUTOTXN' ( stmt )* rollbackstmt 'ENDAUTOTXN' )
            int alt5 = 2;
            int LA5_0 = input.LA(1);
            
            if ( (LA5_0 == 17) )
            {
                alt5 = 1;
            }
            else if ( (LA5_0 == 19) )
            {
                alt5 = 2;
            }
            else 
            {
                if ( backtracking > 0 ) {failed = true; return ;}
                NoViableAltException nvae_d5s0 =
                    new NoViableAltException("93:1: txnstmt : ( 'TXN' ( stmt )* rollbackstmt 'ENDTXN' | 'AUTOTXN' ( stmt )* rollbackstmt 'ENDAUTOTXN' );", 5, 0, input);
            
                throw nvae_d5s0;
            }
            switch (alt5) 
            {
                case 1 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:94:4: 'TXN' ( stmt )* rollbackstmt 'ENDTXN'
                    {
                    	Match(input,17,FOLLOW_17_in_txnstmt167); if (failed) return ;
                    	if ( backtracking == 0 ) 
                    	{
                    	   TxnStart( this, new TextFlowEventArgs( false ) ); 
                    	}
                    	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:94:64: ( stmt )*
                    	do 
                    	{
                    	    int alt3 = 2;
                    	    int LA3_0 = input.LA(1);
                    	    
                    	    if ( (LA3_0 == 17 || LA3_0 == 19 || LA3_0 == 23 || (LA3_0 >= 25 && LA3_0 <= 27) || LA3_0 == 30 || LA3_0 == 33 || LA3_0 == 38 || LA3_0 == 40 || LA3_0 == 44 || LA3_0 == 46) )
                    	    {
                    	        alt3 = 1;
                    	    }
                    	    
                    	
                    	    switch (alt3) 
                    		{
                    			case 1 :
                    			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:94:65: stmt
                    			    {
                    			    	PushFollow(FOLLOW_stmt_in_txnstmt172);
                    			    	stmt();
                    			    	followingStackPointer_--;
                    			    	if (failed) return ;
                    			    
                    			    }
                    			    break;
                    	
                    			default:
                    			    goto loop3;
                    	    }
                    	} while (true);
                    	
                    	loop3:
                    		;	// Stops C# compiler whinging that label 'loop3' has no statements

                    	PushFollow(FOLLOW_rollbackstmt_in_txnstmt176);
                    	rollbackstmt();
                    	followingStackPointer_--;
                    	if (failed) return ;
                    	Match(input,18,FOLLOW_18_in_txnstmt178); if (failed) return ;
                    	if ( backtracking == 0 ) 
                    	{
                    	   TxnEnd( this, new TextFlowEventArgs() ); 
                    	}
                    
                    }
                    break;
                case 2 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:95:4: 'AUTOTXN' ( stmt )* rollbackstmt 'ENDAUTOTXN'
                    {
                    	Match(input,19,FOLLOW_19_in_txnstmt185); if (failed) return ;
                    	if ( backtracking == 0 ) 
                    	{
                    	   TxnStart( this, new TextFlowEventArgs( true ) ); 
                    	}
                    	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:95:67: ( stmt )*
                    	do 
                    	{
                    	    int alt4 = 2;
                    	    int LA4_0 = input.LA(1);
                    	    
                    	    if ( (LA4_0 == 17 || LA4_0 == 19 || LA4_0 == 23 || (LA4_0 >= 25 && LA4_0 <= 27) || LA4_0 == 30 || LA4_0 == 33 || LA4_0 == 38 || LA4_0 == 40 || LA4_0 == 44 || LA4_0 == 46) )
                    	    {
                    	        alt4 = 1;
                    	    }
                    	    
                    	
                    	    switch (alt4) 
                    		{
                    			case 1 :
                    			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:95:68: stmt
                    			    {
                    			    	PushFollow(FOLLOW_stmt_in_txnstmt190);
                    			    	stmt();
                    			    	followingStackPointer_--;
                    			    	if (failed) return ;
                    			    
                    			    }
                    			    break;
                    	
                    			default:
                    			    goto loop4;
                    	    }
                    	} while (true);
                    	
                    	loop4:
                    		;	// Stops C# compiler whinging that label 'loop4' has no statements

                    	PushFollow(FOLLOW_rollbackstmt_in_txnstmt194);
                    	rollbackstmt();
                    	followingStackPointer_--;
                    	if (failed) return ;
                    	Match(input,20,FOLLOW_20_in_txnstmt196); if (failed) return ;
                    	if ( backtracking == 0 ) 
                    	{
                    	   TxnEnd( this, new TextFlowEventArgs() ); 
                    	}
                    
                    }
                    break;
            
            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 3, txnstmt_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end txnstmt

    
    // $ANTLR start rollbackstmt
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:98:1: rollbackstmt : 'UNDO' ( stmt )* 'ENDUNDO' ;
    public void rollbackstmt() // throws RecognitionException [1]
    {   
        int rollbackstmt_StartIndex = input.Index();
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 4) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:99:2: ( 'UNDO' ( stmt )* 'ENDUNDO' )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:99:4: 'UNDO' ( stmt )* 'ENDUNDO'
            {
            	Match(input,21,FOLLOW_21_in_rollbackstmt210); if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   RollbackStart( this, new TextFlowEventArgs() ); 
            	}
            	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:99:63: ( stmt )*
            	do 
            	{
            	    int alt6 = 2;
            	    int LA6_0 = input.LA(1);
            	    
            	    if ( (LA6_0 == 17 || LA6_0 == 19 || LA6_0 == 23 || (LA6_0 >= 25 && LA6_0 <= 27) || LA6_0 == 30 || LA6_0 == 33 || LA6_0 == 38 || LA6_0 == 40 || LA6_0 == 44 || LA6_0 == 46) )
            	    {
            	        alt6 = 1;
            	    }
            	    
            	
            	    switch (alt6) 
            		{
            			case 1 :
            			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:99:64: stmt
            			    {
            			    	PushFollow(FOLLOW_stmt_in_rollbackstmt215);
            			    	stmt();
            			    	followingStackPointer_--;
            			    	if (failed) return ;
            			    
            			    }
            			    break;
            	
            			default:
            			    goto loop6;
            	    }
            	} while (true);
            	
            	loop6:
            		;	// Stops C# compiler whinging that label 'loop6' has no statements

            	Match(input,22,FOLLOW_22_in_rollbackstmt219); if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   RollbackEnd( this, new TextFlowEventArgs() ); 
            	}
            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 4, rollbackstmt_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end rollbackstmt

    
    // $ANTLR start handleerrorstmt
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:102:1: handleerrorstmt : 'ONERROR' ( stmt )* 'ENDERROR' ;
    public void handleerrorstmt() // throws RecognitionException [1]
    {   
        int handleerrorstmt_StartIndex = input.Index();
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 5) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:103:2: ( 'ONERROR' ( stmt )* 'ENDERROR' )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:103:4: 'ONERROR' ( stmt )* 'ENDERROR'
            {
            	Match(input,23,FOLLOW_23_in_handleerrorstmt233); if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   OnErrorStart( this, new TextFlowEventArgs() ); 
            	}
            	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:103:65: ( stmt )*
            	do 
            	{
            	    int alt7 = 2;
            	    int LA7_0 = input.LA(1);
            	    
            	    if ( (LA7_0 == 17 || LA7_0 == 19 || LA7_0 == 23 || (LA7_0 >= 25 && LA7_0 <= 27) || LA7_0 == 30 || LA7_0 == 33 || LA7_0 == 38 || LA7_0 == 40 || LA7_0 == 44 || LA7_0 == 46) )
            	    {
            	        alt7 = 1;
            	    }
            	    
            	
            	    switch (alt7) 
            		{
            			case 1 :
            			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:103:66: stmt
            			    {
            			    	PushFollow(FOLLOW_stmt_in_handleerrorstmt238);
            			    	stmt();
            			    	followingStackPointer_--;
            			    	if (failed) return ;
            			    
            			    }
            			    break;
            	
            			default:
            			    goto loop7;
            	    }
            	} while (true);
            	
            	loop7:
            		;	// Stops C# compiler whinging that label 'loop7' has no statements

            	Match(input,24,FOLLOW_24_in_handleerrorstmt242); if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   OnErrorEnd( this, new TextFlowEventArgs() ); 
            	}
            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 5, handleerrorstmt_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end handleerrorstmt

    
    // $ANTLR start stopstmt
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:106:1: stopstmt : 'STOP' ;
    public void stopstmt() // throws RecognitionException [1]
    {   
        int stopstmt_StartIndex = input.Index();
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 6) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:107:2: ( 'STOP' )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:107:4: 'STOP'
            {
            	Match(input,25,FOLLOW_25_in_stopstmt257); if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   Stop( this, new TextFlowEventArgs() ); 
            	}
            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 6, stopstmt_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end stopstmt

    
    // $ANTLR start errorstmt
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:110:1: errorstmt : 'ERROR' STRING ;
    public void errorstmt() // throws RecognitionException [1]
    {   
        int errorstmt_StartIndex = input.Index();
        IToken STRING1 = null;
    
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 7) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:111:2: ( 'ERROR' STRING )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:111:4: 'ERROR' STRING
            {
            	Match(input,26,FOLLOW_26_in_errorstmt273); if (failed) return ;
            	STRING1 = (IToken)input.LT(1);
            	Match(input,STRING,FOLLOW_STRING_in_errorstmt275); if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   Error( this, new TextFlowEventArgs( STRING1.Text ) ); 
            	}
            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 7, errorstmt_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end errorstmt

    
    // $ANTLR start delaystmt
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:114:1: delaystmt : 'WAITFOR' DECIMAL ( 'SECONDS' | 'MINUTES' ) ;
    public void delaystmt() // throws RecognitionException [1]
    {   
        int delaystmt_StartIndex = input.Index();
        IToken DECIMAL2 = null;
    
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 8) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:115:2: ( 'WAITFOR' DECIMAL ( 'SECONDS' | 'MINUTES' ) )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:115:4: 'WAITFOR' DECIMAL ( 'SECONDS' | 'MINUTES' )
            {
            	Match(input,27,FOLLOW_27_in_delaystmt289); if (failed) return ;
            	DECIMAL2 = (IToken)input.LT(1);
            	Match(input,DECIMAL,FOLLOW_DECIMAL_in_delaystmt291); if (failed) return ;
            	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:115:22: ( 'SECONDS' | 'MINUTES' )
            	int alt8 = 2;
            	int LA8_0 = input.LA(1);
            	
            	if ( (LA8_0 == 28) )
            	{
            	    alt8 = 1;
            	}
            	else if ( (LA8_0 == 29) )
            	{
            	    alt8 = 2;
            	}
            	else 
            	{
            	    if ( backtracking > 0 ) {failed = true; return ;}
            	    NoViableAltException nvae_d8s0 =
            	        new NoViableAltException("115:22: ( 'SECONDS' | 'MINUTES' )", 8, 0, input);
            	
            	    throw nvae_d8s0;
            	}
            	switch (alt8) 
            	{
            	    case 1 :
            	        // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:115:23: 'SECONDS'
            	        {
            	        	Match(input,28,FOLLOW_28_in_delaystmt294); if (failed) return ;
            	        	if ( backtracking == 0 ) 
            	        	{
            	        	   Delay( this, new TextFlowEventArgs( DECIMAL2.Text, "s" ) ); 
            	        	}
            	        
            	        }
            	        break;
            	    case 2 :
            	        // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:115:99: 'MINUTES'
            	        {
            	        	Match(input,29,FOLLOW_29_in_delaystmt300); if (failed) return ;
            	        	if ( backtracking == 0 ) 
            	        	{
            	        	   Delay( this, new TextFlowEventArgs( DECIMAL2.Text, "m" ) ); 
            	        	}
            	        
            	        }
            	        break;
            	
            	}

            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 8, delaystmt_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end delaystmt

    
    // $ANTLR start iterationstmt
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:118:1: iterationstmt : 'REPEAT' DECIMAL 'TIMES' ( stmt )* 'ENDREPEAT' ;
    public void iterationstmt() // throws RecognitionException [1]
    {   
        int iterationstmt_StartIndex = input.Index();
        IToken DECIMAL3 = null;
    
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 9) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:119:2: ( 'REPEAT' DECIMAL 'TIMES' ( stmt )* 'ENDREPEAT' )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:119:4: 'REPEAT' DECIMAL 'TIMES' ( stmt )* 'ENDREPEAT'
            {
            	Match(input,30,FOLLOW_30_in_iterationstmt317); if (failed) return ;
            	DECIMAL3 = (IToken)input.LT(1);
            	Match(input,DECIMAL,FOLLOW_DECIMAL_in_iterationstmt319); if (failed) return ;
            	Match(input,31,FOLLOW_31_in_iterationstmt321); if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   IterationStart( this, new TextFlowEventArgs( DECIMAL3.Text ) ); 
            	}
            	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:119:97: ( stmt )*
            	do 
            	{
            	    int alt9 = 2;
            	    int LA9_0 = input.LA(1);
            	    
            	    if ( (LA9_0 == 17 || LA9_0 == 19 || LA9_0 == 23 || (LA9_0 >= 25 && LA9_0 <= 27) || LA9_0 == 30 || LA9_0 == 33 || LA9_0 == 38 || LA9_0 == 40 || LA9_0 == 44 || LA9_0 == 46) )
            	    {
            	        alt9 = 1;
            	    }
            	    
            	
            	    switch (alt9) 
            		{
            			case 1 :
            			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:119:98: stmt
            			    {
            			    	PushFollow(FOLLOW_stmt_in_iterationstmt326);
            			    	stmt();
            			    	followingStackPointer_--;
            			    	if (failed) return ;
            			    
            			    }
            			    break;
            	
            			default:
            			    goto loop9;
            	    }
            	} while (true);
            	
            	loop9:
            		;	// Stops C# compiler whinging that label 'loop9' has no statements

            	Match(input,32,FOLLOW_32_in_iterationstmt330); if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   IterationEnd( this, new TextFlowEventArgs() ); 
            	}
            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 9, iterationstmt_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end iterationstmt

    
    // $ANTLR start ifstmt
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:122:1: ifstmt : 'IF' expression 'THEN' ( stmt )* ( 'ELSEIF' expression 'THEN' ( stmt )* )* ( 'ELSE' ( stmt )* )? 'ENDIF' ;
    public void ifstmt() // throws RecognitionException [1]
    {   
        int ifstmt_StartIndex = input.Index();
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 10) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:123:2: ( 'IF' expression 'THEN' ( stmt )* ( 'ELSEIF' expression 'THEN' ( stmt )* )* ( 'ELSE' ( stmt )* )? 'ENDIF' )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:123:4: 'IF' expression 'THEN' ( stmt )* ( 'ELSEIF' expression 'THEN' ( stmt )* )* ( 'ELSE' ( stmt )* )? 'ENDIF'
            {
            	Match(input,33,FOLLOW_33_in_ifstmt343); if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   IfStart( this, new TextFlowEventArgs() ); 
            	}
            	PushFollow(FOLLOW_expression_in_ifstmt347);
            	expression();
            	followingStackPointer_--;
            	if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   Condition( this, new TextFlowEventArgs() ); 
            	}
            	Match(input,34,FOLLOW_34_in_ifstmt351); if (failed) return ;
            	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:123:121: ( stmt )*
            	do 
            	{
            	    int alt10 = 2;
            	    int LA10_0 = input.LA(1);
            	    
            	    if ( (LA10_0 == 17 || LA10_0 == 19 || LA10_0 == 23 || (LA10_0 >= 25 && LA10_0 <= 27) || LA10_0 == 30 || LA10_0 == 33 || LA10_0 == 38 || LA10_0 == 40 || LA10_0 == 44 || LA10_0 == 46) )
            	    {
            	        alt10 = 1;
            	    }
            	    
            	
            	    switch (alt10) 
            		{
            			case 1 :
            			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:123:122: stmt
            			    {
            			    	PushFollow(FOLLOW_stmt_in_ifstmt354);
            			    	stmt();
            			    	followingStackPointer_--;
            			    	if (failed) return ;
            			    
            			    }
            			    break;
            	
            			default:
            			    goto loop10;
            	    }
            	} while (true);
            	
            	loop10:
            		;	// Stops C# compiler whinging that label 'loop10' has no statements

            	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:124:4: ( 'ELSEIF' expression 'THEN' ( stmt )* )*
            	do 
            	{
            	    int alt12 = 2;
            	    int LA12_0 = input.LA(1);
            	    
            	    if ( (LA12_0 == 35) )
            	    {
            	        alt12 = 1;
            	    }
            	    
            	
            	    switch (alt12) 
            		{
            			case 1 :
            			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:124:5: 'ELSEIF' expression 'THEN' ( stmt )*
            			    {
            			    	Match(input,35,FOLLOW_35_in_ifstmt362); if (failed) return ;
            			    	if ( backtracking == 0 ) 
            			    	{
            			    	   ElseIfClause( this, new TextFlowEventArgs() ); 
            			    	}
            			    	PushFollow(FOLLOW_expression_in_ifstmt366);
            			    	expression();
            			    	followingStackPointer_--;
            			    	if (failed) return ;
            			    	if ( backtracking == 0 ) 
            			    	{
            			    	   Condition( this, new TextFlowEventArgs() ); 
            			    	}
            			    	Match(input,34,FOLLOW_34_in_ifstmt370); if (failed) return ;
            			    	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:124:131: ( stmt )*
            			    	do 
            			    	{
            			    	    int alt11 = 2;
            			    	    int LA11_0 = input.LA(1);
            			    	    
            			    	    if ( (LA11_0 == 17 || LA11_0 == 19 || LA11_0 == 23 || (LA11_0 >= 25 && LA11_0 <= 27) || LA11_0 == 30 || LA11_0 == 33 || LA11_0 == 38 || LA11_0 == 40 || LA11_0 == 44 || LA11_0 == 46) )
            			    	    {
            			    	        alt11 = 1;
            			    	    }
            			    	    
            			    	
            			    	    switch (alt11) 
            			    		{
            			    			case 1 :
            			    			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:124:132: stmt
            			    			    {
            			    			    	PushFollow(FOLLOW_stmt_in_ifstmt373);
            			    			    	stmt();
            			    			    	followingStackPointer_--;
            			    			    	if (failed) return ;
            			    			    
            			    			    }
            			    			    break;
            			    	
            			    			default:
            			    			    goto loop11;
            			    	    }
            			    	} while (true);
            			    	
            			    	loop11:
            			    		;	// Stops C# compiler whinging that label 'loop11' has no statements

            			    
            			    }
            			    break;
            	
            			default:
            			    goto loop12;
            	    }
            	} while (true);
            	
            	loop12:
            		;	// Stops C# compiler whinging that label 'loop12' has no statements

            	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:125:4: ( 'ELSE' ( stmt )* )?
            	int alt14 = 2;
            	int LA14_0 = input.LA(1);
            	
            	if ( (LA14_0 == 36) )
            	{
            	    alt14 = 1;
            	}
            	switch (alt14) 
            	{
            	    case 1 :
            	        // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:125:5: 'ELSE' ( stmt )*
            	        {
            	        	Match(input,36,FOLLOW_36_in_ifstmt383); if (failed) return ;
            	        	if ( backtracking == 0 ) 
            	        	{
            	        	   ElseClause( this, new TextFlowEventArgs() ); 
            	        	}
            	        	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:125:61: ( stmt )*
            	        	do 
            	        	{
            	        	    int alt13 = 2;
            	        	    int LA13_0 = input.LA(1);
            	        	    
            	        	    if ( (LA13_0 == 17 || LA13_0 == 19 || LA13_0 == 23 || (LA13_0 >= 25 && LA13_0 <= 27) || LA13_0 == 30 || LA13_0 == 33 || LA13_0 == 38 || LA13_0 == 40 || LA13_0 == 44 || LA13_0 == 46) )
            	        	    {
            	        	        alt13 = 1;
            	        	    }
            	        	    
            	        	
            	        	    switch (alt13) 
            	        		{
            	        			case 1 :
            	        			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:125:62: stmt
            	        			    {
            	        			    	PushFollow(FOLLOW_stmt_in_ifstmt388);
            	        			    	stmt();
            	        			    	followingStackPointer_--;
            	        			    	if (failed) return ;
            	        			    
            	        			    }
            	        			    break;
            	        	
            	        			default:
            	        			    goto loop13;
            	        	    }
            	        	} while (true);
            	        	
            	        	loop13:
            	        		;	// Stops C# compiler whinging that label 'loop13' has no statements

            	        
            	        }
            	        break;
            	
            	}

            	Match(input,37,FOLLOW_37_in_ifstmt397); if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   IfEnd( this, new TextFlowEventArgs() ); 
            	}
            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 10, ifstmt_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end ifstmt

    
    // $ANTLR start whilestmt
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:129:1: whilestmt : 'WHILE' expression ( stmt )* 'ENDWHILE' ;
    public void whilestmt() // throws RecognitionException [1]
    {   
        int whilestmt_StartIndex = input.Index();
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 11) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:130:2: ( 'WHILE' expression ( stmt )* 'ENDWHILE' )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:130:4: 'WHILE' expression ( stmt )* 'ENDWHILE'
            {
            	Match(input,38,FOLLOW_38_in_whilestmt411); if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   WhileStart( this, new TextFlowEventArgs() ); 
            	}
            	PushFollow(FOLLOW_expression_in_whilestmt415);
            	expression();
            	followingStackPointer_--;
            	if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   Condition( this, new TextFlowEventArgs() ); 
            	}
            	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:130:120: ( stmt )*
            	do 
            	{
            	    int alt15 = 2;
            	    int LA15_0 = input.LA(1);
            	    
            	    if ( (LA15_0 == 17 || LA15_0 == 19 || LA15_0 == 23 || (LA15_0 >= 25 && LA15_0 <= 27) || LA15_0 == 30 || LA15_0 == 33 || LA15_0 == 38 || LA15_0 == 40 || LA15_0 == 44 || LA15_0 == 46) )
            	    {
            	        alt15 = 1;
            	    }
            	    
            	
            	    switch (alt15) 
            		{
            			case 1 :
            			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:130:121: stmt
            			    {
            			    	PushFollow(FOLLOW_stmt_in_whilestmt420);
            			    	stmt();
            			    	followingStackPointer_--;
            			    	if (failed) return ;
            			    
            			    }
            			    break;
            	
            			default:
            			    goto loop15;
            	    }
            	} while (true);
            	
            	loop15:
            		;	// Stops C# compiler whinging that label 'loop15' has no statements

            	Match(input,39,FOLLOW_39_in_whilestmt424); if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   WhileEnd( this, new TextFlowEventArgs() ); 
            	}
            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 11, whilestmt_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end whilestmt

    
    // $ANTLR start parallelstmt
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:133:1: parallelstmt : 'INPARALLEL' ( 'START' ( stmt )* 'END' )+ 'ENDPARALLEL' ;
    public void parallelstmt() // throws RecognitionException [1]
    {   
        int parallelstmt_StartIndex = input.Index();
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 12) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:134:2: ( 'INPARALLEL' ( 'START' ( stmt )* 'END' )+ 'ENDPARALLEL' )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:134:4: 'INPARALLEL' ( 'START' ( stmt )* 'END' )+ 'ENDPARALLEL'
            {
            	Match(input,40,FOLLOW_40_in_parallelstmt439); if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   ParallelStart( this, new TextFlowEventArgs() ); 
            	}
            	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:135:4: ( 'START' ( stmt )* 'END' )+
            	int cnt17 = 0;
            	do 
            	{
            	    int alt17 = 2;
            	    int LA17_0 = input.LA(1);
            	    
            	    if ( (LA17_0 == 41) )
            	    {
            	        alt17 = 1;
            	    }
            	    
            	
            	    switch (alt17) 
            		{
            			case 1 :
            			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:135:6: 'START' ( stmt )* 'END'
            			    {
            			    	if ( backtracking == 0 ) 
            			    	{
            			    	   ParallelChildStart( this, new TextFlowEventArgs() ); 
            			    	}
            			    	Match(input,41,FOLLOW_41_in_parallelstmt450); if (failed) return ;
            			    	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:135:71: ( stmt )*
            			    	do 
            			    	{
            			    	    int alt16 = 2;
            			    	    int LA16_0 = input.LA(1);
            			    	    
            			    	    if ( (LA16_0 == 17 || LA16_0 == 19 || LA16_0 == 23 || (LA16_0 >= 25 && LA16_0 <= 27) || LA16_0 == 30 || LA16_0 == 33 || LA16_0 == 38 || LA16_0 == 40 || LA16_0 == 44 || LA16_0 == 46) )
            			    	    {
            			    	        alt16 = 1;
            			    	    }
            			    	    
            			    	
            			    	    switch (alt16) 
            			    		{
            			    			case 1 :
            			    			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:135:72: stmt
            			    			    {
            			    			    	PushFollow(FOLLOW_stmt_in_parallelstmt453);
            			    			    	stmt();
            			    			    	followingStackPointer_--;
            			    			    	if (failed) return ;
            			    			    
            			    			    }
            			    			    break;
            			    	
            			    			default:
            			    			    goto loop16;
            			    	    }
            			    	} while (true);
            			    	
            			    	loop16:
            			    		;	// Stops C# compiler whinging that label 'loop16' has no statements

            			    	Match(input,42,FOLLOW_42_in_parallelstmt457); if (failed) return ;
            			    	if ( backtracking == 0 ) 
            			    	{
            			    	   ParallelChildEnd( this, new TextFlowEventArgs() ); 
            			    	}
            			    
            			    }
            			    break;
            	
            			default:
            			    if ( cnt17 >= 1 ) goto loop17;
            			    if ( backtracking > 0 ) {failed = true; return ;}
            		            EarlyExitException eee =
            		                new EarlyExitException(17, input);
            		            throw eee;
            	    }
            	    cnt17++;
            	} while (true);
            	
            	loop17:
            		;	// Stops C# compiler whinging that label 'loop17' has no statements

            	Match(input,43,FOLLOW_43_in_parallelstmt467); if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   ParallelEnd( this, new TextFlowEventArgs() ); 
            	}
            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 12, parallelstmt_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end parallelstmt

    
    // $ANTLR start assignmentstmt
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:139:1: assignmentstmt : 'SET' ID '=' expression ;
    public void assignmentstmt() // throws RecognitionException [1]
    {   
        int assignmentstmt_StartIndex = input.Index();
        IToken ID4 = null;
    
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 13) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:140:2: ( 'SET' ID '=' expression )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:140:4: 'SET' ID '=' expression
            {
            	Match(input,44,FOLLOW_44_in_assignmentstmt480); if (failed) return ;
            	ID4 = (IToken)input.LT(1);
            	Match(input,ID,FOLLOW_ID_in_assignmentstmt482); if (failed) return ;
            	Match(input,45,FOLLOW_45_in_assignmentstmt484); if (failed) return ;
            	PushFollow(FOLLOW_expression_in_assignmentstmt486);
            	expression();
            	followingStackPointer_--;
            	if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   Assign( this, new TextFlowEventArgs( ID4.Text ) ); 
            	}
            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 13, assignmentstmt_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end assignmentstmt

    
    // $ANTLR start actionstmt
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:143:1: actionstmt : '[' ( actionInput )* ID ( actionOutput )* ']' ;
    public void actionstmt() // throws RecognitionException [1]
    {   
        int actionstmt_StartIndex = input.Index();
        IToken ID5 = null;
    
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 14) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:144:2: ( '[' ( actionInput )* ID ( actionOutput )* ']' )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:144:4: '[' ( actionInput )* ID ( actionOutput )* ']'
            {
            	Match(input,46,FOLLOW_46_in_actionstmt499); if (failed) return ;
            	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:144:8: ( actionInput )*
            	do 
            	{
            	    int alt18 = 2;
            	    int LA18_0 = input.LA(1);
            	    
            	    if ( (LA18_0 == ID) )
            	    {
            	        int LA18_1 = input.LA(2);
            	        
            	        if ( (LA18_1 == 48 || (LA18_1 >= 52 && LA18_1 <= 53) || (LA18_1 >= 55 && LA18_1 <= 65)) )
            	        {
            	            alt18 = 1;
            	        }
            	        
            	    
            	    }
            	    else if ( ((LA18_0 >= STRING && LA18_0 <= DECIMAL) || (LA18_0 >= FLOAT && LA18_0 <= LPAREN) || (LA18_0 >= 49 && LA18_0 <= 51) || LA18_0 == 54 || LA18_0 == 62) )
            	    {
            	        alt18 = 1;
            	    }
            	    
            	
            	    switch (alt18) 
            		{
            			case 1 :
            			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:0:0: actionInput
            			    {
            			    	PushFollow(FOLLOW_actionInput_in_actionstmt501);
            			    	actionInput();
            			    	followingStackPointer_--;
            			    	if (failed) return ;
            			    
            			    }
            			    break;
            	
            			default:
            			    goto loop18;
            	    }
            	} while (true);
            	
            	loop18:
            		;	// Stops C# compiler whinging that label 'loop18' has no statements

            	ID5 = (IToken)input.LT(1);
            	Match(input,ID,FOLLOW_ID_in_actionstmt504); if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   Action( this, new TextFlowEventArgs( ID5.Text ) ); 
            	}
            	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:144:79: ( actionOutput )*
            	do 
            	{
            	    int alt19 = 2;
            	    int LA19_0 = input.LA(1);
            	    
            	    if ( (LA19_0 == ID) )
            	    {
            	        alt19 = 1;
            	    }
            	    
            	
            	    switch (alt19) 
            		{
            			case 1 :
            			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:0:0: actionOutput
            			    {
            			    	PushFollow(FOLLOW_actionOutput_in_actionstmt508);
            			    	actionOutput();
            			    	followingStackPointer_--;
            			    	if (failed) return ;
            			    
            			    }
            			    break;
            	
            			default:
            			    goto loop19;
            	    }
            	} while (true);
            	
            	loop19:
            		;	// Stops C# compiler whinging that label 'loop19' has no statements

            	Match(input,47,FOLLOW_47_in_actionstmt511); if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   PostAction( this, new TextFlowEventArgs( ID5.Text ) ); 
            	}
            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 14, actionstmt_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end actionstmt

    
    // $ANTLR start actionInput
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:147:1: actionInput : expression '=>' ID ;
    public void actionInput() // throws RecognitionException [1]
    {   
        int actionInput_StartIndex = input.Index();
        IToken ID6 = null;
    
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 15) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:148:2: ( expression '=>' ID )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:148:4: expression '=>' ID
            {
            	PushFollow(FOLLOW_expression_in_actionInput526);
            	expression();
            	followingStackPointer_--;
            	if (failed) return ;
            	Match(input,48,FOLLOW_48_in_actionInput528); if (failed) return ;
            	ID6 = (IToken)input.LT(1);
            	Match(input,ID,FOLLOW_ID_in_actionInput530); if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   ActionInput( this, new TextFlowEventArgs( ID6.Text ) ); 
            	}
            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 15, actionInput_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end actionInput

    
    // $ANTLR start actionOutput
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:151:1: actionOutput : prop= ID '=>' id= ID ;
    public void actionOutput() // throws RecognitionException [1]
    {   
        int actionOutput_StartIndex = input.Index();
        IToken prop = null;
        IToken id = null;
    
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 16) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:152:2: (prop= ID '=>' id= ID )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:152:4: prop= ID '=>' id= ID
            {
            	prop = (IToken)input.LT(1);
            	Match(input,ID,FOLLOW_ID_in_actionOutput547); if (failed) return ;
            	Match(input,48,FOLLOW_48_in_actionOutput549); if (failed) return ;
            	id = (IToken)input.LT(1);
            	Match(input,ID,FOLLOW_ID_in_actionOutput553); if (failed) return ;
            	if ( backtracking == 0 ) 
            	{
            	   ActionOutput( this, new TextFlowEventArgs( prop.Text, id.Text ) ); 
            	}
            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 16, actionOutput_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end actionOutput

    
    // $ANTLR start literal
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:155:1: literal : ( DECIMAL | FLOAT | CHAR | STRING | 'TRUE' | 'FALSE' | 'NULL' );
    public void literal() // throws RecognitionException [1]
    {   
        int literal_StartIndex = input.Index();
        IToken DECIMAL7 = null;
        IToken FLOAT8 = null;
        IToken CHAR9 = null;
        IToken STRING10 = null;
    
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 17) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:156:2: ( DECIMAL | FLOAT | CHAR | STRING | 'TRUE' | 'FALSE' | 'NULL' )
            int alt20 = 7;
            switch ( input.LA(1) ) 
            {
            case DECIMAL:
            	{
                alt20 = 1;
                }
                break;
            case FLOAT:
            	{
                alt20 = 2;
                }
                break;
            case CHAR:
            	{
                alt20 = 3;
                }
                break;
            case STRING:
            	{
                alt20 = 4;
                }
                break;
            case 49:
            	{
                alt20 = 5;
                }
                break;
            case 50:
            	{
                alt20 = 6;
                }
                break;
            case 51:
            	{
                alt20 = 7;
                }
                break;
            	default:
            	    if ( backtracking > 0 ) {failed = true; return ;}
            	    NoViableAltException nvae_d20s0 =
            	        new NoViableAltException("155:1: literal : ( DECIMAL | FLOAT | CHAR | STRING | 'TRUE' | 'FALSE' | 'NULL' );", 20, 0, input);
            
            	    throw nvae_d20s0;
            }
            
            switch (alt20) 
            {
                case 1 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:156:6: DECIMAL
                    {
                    	DECIMAL7 = (IToken)input.LT(1);
                    	Match(input,DECIMAL,FOLLOW_DECIMAL_in_literal571); if (failed) return ;
                    	if ( backtracking == 0 ) 
                    	{
                    	   Literal( this, new TextFlowEventArgs( typeof( decimal ), DECIMAL7.Text ) ); 
                    	}
                    
                    }
                    break;
                case 2 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:157:6: FLOAT
                    {
                    	FLOAT8 = (IToken)input.LT(1);
                    	Match(input,FLOAT,FOLLOW_FLOAT_in_literal580); if (failed) return ;
                    	if ( backtracking == 0 ) 
                    	{
                    	   Literal( this, new TextFlowEventArgs( typeof( double ), FLOAT8.Text ) ); 
                    	}
                    
                    }
                    break;
                case 3 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:158:6: CHAR
                    {
                    	CHAR9 = (IToken)input.LT(1);
                    	Match(input,CHAR,FOLLOW_CHAR_in_literal589); if (failed) return ;
                    	if ( backtracking == 0 ) 
                    	{
                    	   Literal( this, new TextFlowEventArgs( typeof( char ), CHAR9.Text ) ); 
                    	}
                    
                    }
                    break;
                case 4 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:159:6: STRING
                    {
                    	STRING10 = (IToken)input.LT(1);
                    	Match(input,STRING,FOLLOW_STRING_in_literal598); if (failed) return ;
                    	if ( backtracking == 0 ) 
                    	{
                    	   Literal( this, new TextFlowEventArgs( typeof( string ), STRING10.Text ) ); 
                    	}
                    
                    }
                    break;
                case 5 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:160:6: 'TRUE'
                    {
                    	Match(input,49,FOLLOW_49_in_literal607); if (failed) return ;
                    	if ( backtracking == 0 ) 
                    	{
                    	   Literal( this, new TextFlowEventArgs( typeof( bool ), "TRUE" ) ); 
                    	}
                    
                    }
                    break;
                case 6 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:161:6: 'FALSE'
                    {
                    	Match(input,50,FOLLOW_50_in_literal616); if (failed) return ;
                    	if ( backtracking == 0 ) 
                    	{
                    	   Literal( this, new TextFlowEventArgs( typeof( bool ), "FALSE" ) ); 
                    	}
                    
                    }
                    break;
                case 7 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:162:6: 'NULL'
                    {
                    	Match(input,51,FOLLOW_51_in_literal625); if (failed) return ;
                    	if ( backtracking == 0 ) 
                    	{
                    	   Literal( this, new TextFlowEventArgs() ); 
                    	}
                    
                    }
                    break;
            
            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 17, literal_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end literal

    
    // $ANTLR start expression
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:165:1: expression : conditionalAndExpression ( 'OR' conditionalAndExpression )* ;
    public void expression() // throws RecognitionException [1]
    {   
        int expression_StartIndex = input.Index();
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 18) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:166:2: ( conditionalAndExpression ( 'OR' conditionalAndExpression )* )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:166:4: conditionalAndExpression ( 'OR' conditionalAndExpression )*
            {
            	PushFollow(FOLLOW_conditionalAndExpression_in_expression640);
            	conditionalAndExpression();
            	followingStackPointer_--;
            	if (failed) return ;
            	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:166:29: ( 'OR' conditionalAndExpression )*
            	do 
            	{
            	    int alt21 = 2;
            	    int LA21_0 = input.LA(1);
            	    
            	    if ( (LA21_0 == 52) )
            	    {
            	        alt21 = 1;
            	    }
            	    
            	
            	    switch (alt21) 
            		{
            			case 1 :
            			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:166:31: 'OR' conditionalAndExpression
            			    {
            			    	Match(input,52,FOLLOW_52_in_expression644); if (failed) return ;
            			    	PushFollow(FOLLOW_conditionalAndExpression_in_expression646);
            			    	conditionalAndExpression();
            			    	followingStackPointer_--;
            			    	if (failed) return ;
            			    	if ( backtracking == 0 ) 
            			    	{
            			    	   Compare( this, new TextFlowEventArgs( "OR" ) ); 
            			    	}
            			    
            			    }
            			    break;
            	
            			default:
            			    goto loop21;
            	    }
            	} while (true);
            	
            	loop21:
            		;	// Stops C# compiler whinging that label 'loop21' has no statements

            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 18, expression_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end expression

    
    // $ANTLR start conditionalAndExpression
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:169:1: conditionalAndExpression : conditionalNotExpression ( 'AND' conditionalNotExpression )* ;
    public void conditionalAndExpression() // throws RecognitionException [1]
    {   
        int conditionalAndExpression_StartIndex = input.Index();
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 19) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:170:2: ( conditionalNotExpression ( 'AND' conditionalNotExpression )* )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:170:4: conditionalNotExpression ( 'AND' conditionalNotExpression )*
            {
            	PushFollow(FOLLOW_conditionalNotExpression_in_conditionalAndExpression662);
            	conditionalNotExpression();
            	followingStackPointer_--;
            	if (failed) return ;
            	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:170:29: ( 'AND' conditionalNotExpression )*
            	do 
            	{
            	    int alt22 = 2;
            	    int LA22_0 = input.LA(1);
            	    
            	    if ( (LA22_0 == 53) )
            	    {
            	        alt22 = 1;
            	    }
            	    
            	
            	    switch (alt22) 
            		{
            			case 1 :
            			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:170:31: 'AND' conditionalNotExpression
            			    {
            			    	Match(input,53,FOLLOW_53_in_conditionalAndExpression666); if (failed) return ;
            			    	PushFollow(FOLLOW_conditionalNotExpression_in_conditionalAndExpression668);
            			    	conditionalNotExpression();
            			    	followingStackPointer_--;
            			    	if (failed) return ;
            			    	if ( backtracking == 0 ) 
            			    	{
            			    	   Compare( this, new TextFlowEventArgs( "AND" ) ); 
            			    	}
            			    
            			    }
            			    break;
            	
            			default:
            			    goto loop22;
            	    }
            	} while (true);
            	
            	loop22:
            		;	// Stops C# compiler whinging that label 'loop22' has no statements

            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 19, conditionalAndExpression_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end conditionalAndExpression

    
    // $ANTLR start conditionalNotExpression
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:173:1: conditionalNotExpression : ( 'NOT' )? equalityExpression ;
    public void conditionalNotExpression() // throws RecognitionException [1]
    {   
        int conditionalNotExpression_StartIndex = input.Index();
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 20) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:174:2: ( ( 'NOT' )? equalityExpression )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:174:4: ( 'NOT' )? equalityExpression
            {
            	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:174:4: ( 'NOT' )?
            	int alt23 = 2;
            	int LA23_0 = input.LA(1);
            	
            	if ( (LA23_0 == 54) )
            	{
            	    alt23 = 1;
            	}
            	switch (alt23) 
            	{
            	    case 1 :
            	        // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:174:6: 'NOT'
            	        {
            	        	Match(input,54,FOLLOW_54_in_conditionalNotExpression686); if (failed) return ;
            	        	if ( backtracking == 0 ) 
            	        	{
            	        	   Compare( this, new TextFlowEventArgs( "NOT" ) ); 
            	        	}
            	        
            	        }
            	        break;
            	
            	}

            	PushFollow(FOLLOW_equalityExpression_in_conditionalNotExpression693);
            	equalityExpression();
            	followingStackPointer_--;
            	if (failed) return ;
            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 20, conditionalNotExpression_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end conditionalNotExpression

    
    // $ANTLR start equalityExpression
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:177:1: equalityExpression : additiveExpression ( (x= '==' | x= '!=' | x= '<=' | x= '>=' | x= '<' | x= '>' ) additiveExpression )* ;
    public void equalityExpression() // throws RecognitionException [1]
    {   
        int equalityExpression_StartIndex = input.Index();
        IToken x = null;
    
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 21) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:178:2: ( additiveExpression ( (x= '==' | x= '!=' | x= '<=' | x= '>=' | x= '<' | x= '>' ) additiveExpression )* )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:178:4: additiveExpression ( (x= '==' | x= '!=' | x= '<=' | x= '>=' | x= '<' | x= '>' ) additiveExpression )*
            {
            	PushFollow(FOLLOW_additiveExpression_in_equalityExpression704);
            	additiveExpression();
            	followingStackPointer_--;
            	if (failed) return ;
            	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:178:23: ( (x= '==' | x= '!=' | x= '<=' | x= '>=' | x= '<' | x= '>' ) additiveExpression )*
            	do 
            	{
            	    int alt25 = 2;
            	    int LA25_0 = input.LA(1);
            	    
            	    if ( ((LA25_0 >= 55 && LA25_0 <= 60)) )
            	    {
            	        alt25 = 1;
            	    }
            	    
            	
            	    switch (alt25) 
            		{
            			case 1 :
            			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:178:25: (x= '==' | x= '!=' | x= '<=' | x= '>=' | x= '<' | x= '>' ) additiveExpression
            			    {
            			    	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:178:25: (x= '==' | x= '!=' | x= '<=' | x= '>=' | x= '<' | x= '>' )
            			    	int alt24 = 6;
            			    	switch ( input.LA(1) ) 
            			    	{
            			    	case 55:
            			    		{
            			    	    alt24 = 1;
            			    	    }
            			    	    break;
            			    	case 56:
            			    		{
            			    	    alt24 = 2;
            			    	    }
            			    	    break;
            			    	case 57:
            			    		{
            			    	    alt24 = 3;
            			    	    }
            			    	    break;
            			    	case 58:
            			    		{
            			    	    alt24 = 4;
            			    	    }
            			    	    break;
            			    	case 59:
            			    		{
            			    	    alt24 = 5;
            			    	    }
            			    	    break;
            			    	case 60:
            			    		{
            			    	    alt24 = 6;
            			    	    }
            			    	    break;
            			    		default:
            			    		    if ( backtracking > 0 ) {failed = true; return ;}
            			    		    NoViableAltException nvae_d24s0 =
            			    		        new NoViableAltException("178:25: (x= '==' | x= '!=' | x= '<=' | x= '>=' | x= '<' | x= '>' )", 24, 0, input);
            			    	
            			    		    throw nvae_d24s0;
            			    	}
            			    	
            			    	switch (alt24) 
            			    	{
            			    	    case 1 :
            			    	        // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:178:26: x= '=='
            			    	        {
            			    	        	x = (IToken)input.LT(1);
            			    	        	Match(input,55,FOLLOW_55_in_equalityExpression711); if (failed) return ;
            			    	        
            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:178:33: x= '!='
            			    	        {
            			    	        	x = (IToken)input.LT(1);
            			    	        	Match(input,56,FOLLOW_56_in_equalityExpression715); if (failed) return ;
            			    	        
            			    	        }
            			    	        break;
            			    	    case 3 :
            			    	        // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:178:40: x= '<='
            			    	        {
            			    	        	x = (IToken)input.LT(1);
            			    	        	Match(input,57,FOLLOW_57_in_equalityExpression719); if (failed) return ;
            			    	        
            			    	        }
            			    	        break;
            			    	    case 4 :
            			    	        // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:178:47: x= '>='
            			    	        {
            			    	        	x = (IToken)input.LT(1);
            			    	        	Match(input,58,FOLLOW_58_in_equalityExpression723); if (failed) return ;
            			    	        
            			    	        }
            			    	        break;
            			    	    case 5 :
            			    	        // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:178:54: x= '<'
            			    	        {
            			    	        	x = (IToken)input.LT(1);
            			    	        	Match(input,59,FOLLOW_59_in_equalityExpression727); if (failed) return ;
            			    	        
            			    	        }
            			    	        break;
            			    	    case 6 :
            			    	        // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:178:60: x= '>'
            			    	        {
            			    	        	x = (IToken)input.LT(1);
            			    	        	Match(input,60,FOLLOW_60_in_equalityExpression731); if (failed) return ;
            			    	        
            			    	        }
            			    	        break;
            			    	
            			    	}

            			    	PushFollow(FOLLOW_additiveExpression_in_equalityExpression734);
            			    	additiveExpression();
            			    	followingStackPointer_--;
            			    	if (failed) return ;
            			    	if ( backtracking == 0 ) 
            			    	{
            			    	   Compare( this, new TextFlowEventArgs( x.Text ) ); 
            			    	}
            			    
            			    }
            			    break;
            	
            			default:
            			    goto loop25;
            	    }
            	} while (true);
            	
            	loop25:
            		;	// Stops C# compiler whinging that label 'loop25' has no statements

            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 21, equalityExpression_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end equalityExpression

    
    // $ANTLR start additiveExpression
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:181:1: additiveExpression : multiplicativeExpression ( (x= '+' | x= '-' ) multiplicativeExpression )* ;
    public void additiveExpression() // throws RecognitionException [1]
    {   
        int additiveExpression_StartIndex = input.Index();
        IToken x = null;
    
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 22) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:182:2: ( multiplicativeExpression ( (x= '+' | x= '-' ) multiplicativeExpression )* )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:182:4: multiplicativeExpression ( (x= '+' | x= '-' ) multiplicativeExpression )*
            {
            	PushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression750);
            	multiplicativeExpression();
            	followingStackPointer_--;
            	if (failed) return ;
            	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:182:29: ( (x= '+' | x= '-' ) multiplicativeExpression )*
            	do 
            	{
            	    int alt27 = 2;
            	    int LA27_0 = input.LA(1);
            	    
            	    if ( ((LA27_0 >= 61 && LA27_0 <= 62)) )
            	    {
            	        alt27 = 1;
            	    }
            	    
            	
            	    switch (alt27) 
            		{
            			case 1 :
            			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:182:31: (x= '+' | x= '-' ) multiplicativeExpression
            			    {
            			    	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:182:31: (x= '+' | x= '-' )
            			    	int alt26 = 2;
            			    	int LA26_0 = input.LA(1);
            			    	
            			    	if ( (LA26_0 == 61) )
            			    	{
            			    	    alt26 = 1;
            			    	}
            			    	else if ( (LA26_0 == 62) )
            			    	{
            			    	    alt26 = 2;
            			    	}
            			    	else 
            			    	{
            			    	    if ( backtracking > 0 ) {failed = true; return ;}
            			    	    NoViableAltException nvae_d26s0 =
            			    	        new NoViableAltException("182:31: (x= '+' | x= '-' )", 26, 0, input);
            			    	
            			    	    throw nvae_d26s0;
            			    	}
            			    	switch (alt26) 
            			    	{
            			    	    case 1 :
            			    	        // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:182:32: x= '+'
            			    	        {
            			    	        	x = (IToken)input.LT(1);
            			    	        	Match(input,61,FOLLOW_61_in_additiveExpression757); if (failed) return ;
            			    	        
            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:182:38: x= '-'
            			    	        {
            			    	        	x = (IToken)input.LT(1);
            			    	        	Match(input,62,FOLLOW_62_in_additiveExpression761); if (failed) return ;
            			    	        
            			    	        }
            			    	        break;
            			    	
            			    	}

            			    	PushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression764);
            			    	multiplicativeExpression();
            			    	followingStackPointer_--;
            			    	if (failed) return ;
            			    	if ( backtracking == 0 ) 
            			    	{
            			    	   Math( this, new TextFlowEventArgs( x.Text ) ); 
            			    	}
            			    
            			    }
            			    break;
            	
            			default:
            			    goto loop27;
            	    }
            	} while (true);
            	
            	loop27:
            		;	// Stops C# compiler whinging that label 'loop27' has no statements

            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 22, additiveExpression_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end additiveExpression

    
    // $ANTLR start multiplicativeExpression
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:185:1: multiplicativeExpression : unaryExpression ( (x= '*' | x= '/' ) unaryExpression )* ;
    public void multiplicativeExpression() // throws RecognitionException [1]
    {   
        int multiplicativeExpression_StartIndex = input.Index();
        IToken x = null;
    
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 23) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:186:2: ( unaryExpression ( (x= '*' | x= '/' ) unaryExpression )* )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:186:4: unaryExpression ( (x= '*' | x= '/' ) unaryExpression )*
            {
            	PushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression780);
            	unaryExpression();
            	followingStackPointer_--;
            	if (failed) return ;
            	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:186:20: ( (x= '*' | x= '/' ) unaryExpression )*
            	do 
            	{
            	    int alt29 = 2;
            	    int LA29_0 = input.LA(1);
            	    
            	    if ( ((LA29_0 >= 63 && LA29_0 <= 64)) )
            	    {
            	        alt29 = 1;
            	    }
            	    
            	
            	    switch (alt29) 
            		{
            			case 1 :
            			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:186:22: (x= '*' | x= '/' ) unaryExpression
            			    {
            			    	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:186:22: (x= '*' | x= '/' )
            			    	int alt28 = 2;
            			    	int LA28_0 = input.LA(1);
            			    	
            			    	if ( (LA28_0 == 63) )
            			    	{
            			    	    alt28 = 1;
            			    	}
            			    	else if ( (LA28_0 == 64) )
            			    	{
            			    	    alt28 = 2;
            			    	}
            			    	else 
            			    	{
            			    	    if ( backtracking > 0 ) {failed = true; return ;}
            			    	    NoViableAltException nvae_d28s0 =
            			    	        new NoViableAltException("186:22: (x= '*' | x= '/' )", 28, 0, input);
            			    	
            			    	    throw nvae_d28s0;
            			    	}
            			    	switch (alt28) 
            			    	{
            			    	    case 1 :
            			    	        // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:186:23: x= '*'
            			    	        {
            			    	        	x = (IToken)input.LT(1);
            			    	        	Match(input,63,FOLLOW_63_in_multiplicativeExpression787); if (failed) return ;
            			    	        
            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:186:29: x= '/'
            			    	        {
            			    	        	x = (IToken)input.LT(1);
            			    	        	Match(input,64,FOLLOW_64_in_multiplicativeExpression791); if (failed) return ;
            			    	        
            			    	        }
            			    	        break;
            			    	
            			    	}

            			    	PushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression794);
            			    	unaryExpression();
            			    	followingStackPointer_--;
            			    	if (failed) return ;
            			    	if ( backtracking == 0 ) 
            			    	{
            			    	   Math( this, new TextFlowEventArgs( x.Text ) ); 
            			    	}
            			    
            			    }
            			    break;
            	
            			default:
            			    goto loop29;
            	    }
            	} while (true);
            	
            	loop29:
            		;	// Stops C# compiler whinging that label 'loop29' has no statements

            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 23, multiplicativeExpression_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end multiplicativeExpression

    
    // $ANTLR start unaryExpression
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:189:1: unaryExpression : ( '-' unaryExpression | LPAREN expression RPAREN | functionCall | literal | ID );
    public void unaryExpression() // throws RecognitionException [1]
    {   
        int unaryExpression_StartIndex = input.Index();
        IToken ID11 = null;
    
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 24) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:190:2: ( '-' unaryExpression | LPAREN expression RPAREN | functionCall | literal | ID )
            int alt30 = 5;
            switch ( input.LA(1) ) 
            {
            case 62:
            	{
                alt30 = 1;
                }
                break;
            case LPAREN:
            	{
                alt30 = 2;
                }
                break;
            case ID:
            	{
                int LA30_3 = input.LA(2);
                
                if ( (LA30_3 == 65) )
                {
                    alt30 = 3;
                }
                else if ( (LA30_3 == EOF || LA30_3 == RPAREN || LA30_3 == 17 || LA30_3 == 19 || (LA30_3 >= 21 && LA30_3 <= 27) || LA30_3 == 30 || (LA30_3 >= 32 && LA30_3 <= 40) || LA30_3 == 42 || LA30_3 == 44 || LA30_3 == 46 || LA30_3 == 48 || (LA30_3 >= 52 && LA30_3 <= 53) || (LA30_3 >= 55 && LA30_3 <= 64) || LA30_3 == 67) )
                {
                    alt30 = 5;
                }
                else 
                {
                    if ( backtracking > 0 ) {failed = true; return ;}
                    NoViableAltException nvae_d30s3 =
                        new NoViableAltException("189:1: unaryExpression : ( '-' unaryExpression | LPAREN expression RPAREN | functionCall | literal | ID );", 30, 3, input);
                
                    throw nvae_d30s3;
                }
                }
                break;
            case STRING:
            case DECIMAL:
            case FLOAT:
            case CHAR:
            case 49:
            case 50:
            case 51:
            	{
                alt30 = 4;
                }
                break;
            	default:
            	    if ( backtracking > 0 ) {failed = true; return ;}
            	    NoViableAltException nvae_d30s0 =
            	        new NoViableAltException("189:1: unaryExpression : ( '-' unaryExpression | LPAREN expression RPAREN | functionCall | literal | ID );", 30, 0, input);
            
            	    throw nvae_d30s0;
            }
            
            switch (alt30) 
            {
                case 1 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:190:4: '-' unaryExpression
                    {
                    	Match(input,62,FOLLOW_62_in_unaryExpression811); if (failed) return ;
                    	PushFollow(FOLLOW_unaryExpression_in_unaryExpression813);
                    	unaryExpression();
                    	followingStackPointer_--;
                    	if (failed) return ;
                    	if ( backtracking == 0 ) 
                    	{
                    	   Math( this, new TextFlowEventArgs( "Negate" ) ); 
                    	}
                    
                    }
                    break;
                case 2 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:191:4: LPAREN expression RPAREN
                    {
                    	Match(input,LPAREN,FOLLOW_LPAREN_in_unaryExpression822); if (failed) return ;
                    	PushFollow(FOLLOW_expression_in_unaryExpression824);
                    	expression();
                    	followingStackPointer_--;
                    	if (failed) return ;
                    	Match(input,RPAREN,FOLLOW_RPAREN_in_unaryExpression826); if (failed) return ;
                    
                    }
                    break;
                case 3 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:192:4: functionCall
                    {
                    	PushFollow(FOLLOW_functionCall_in_unaryExpression831);
                    	functionCall();
                    	followingStackPointer_--;
                    	if (failed) return ;
                    
                    }
                    break;
                case 4 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:193:4: literal
                    {
                    	PushFollow(FOLLOW_literal_in_unaryExpression836);
                    	literal();
                    	followingStackPointer_--;
                    	if (failed) return ;
                    
                    }
                    break;
                case 5 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:194:4: ID
                    {
                    	ID11 = (IToken)input.LT(1);
                    	Match(input,ID,FOLLOW_ID_in_unaryExpression841); if (failed) return ;
                    	if ( backtracking == 0 ) 
                    	{
                    	   Lookup( this, new TextFlowEventArgs( ID11.Text ) ); 
                    	}
                    
                    }
                    break;
            
            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 24, unaryExpression_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end unaryExpression

    
    // $ANTLR start functionCall
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:197:1: functionCall : (svc= ID '.' method= ID '(' count= functionArgs ')' | svc= ID '.' method= ID '()' | svc= ID '.' prop= ID );
    public void functionCall() // throws RecognitionException [1]
    {   
        int functionCall_StartIndex = input.Index();
        IToken svc = null;
        IToken method = null;
        IToken prop = null;
        int count = 0;
        
    
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 25) ) 
    	    {
    	    	return ; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:198:2: (svc= ID '.' method= ID '(' count= functionArgs ')' | svc= ID '.' method= ID '()' | svc= ID '.' prop= ID )
            int alt31 = 3;
            int LA31_0 = input.LA(1);
            
            if ( (LA31_0 == ID) )
            {
                int LA31_1 = input.LA(2);
                
                if ( (LA31_1 == 65) )
                {
                    int LA31_2 = input.LA(3);
                    
                    if ( (synpred52()) )
                    {
                        alt31 = 1;
                    }
                    else if ( (synpred53()) )
                    {
                        alt31 = 2;
                    }
                    else if ( (true) )
                    {
                        alt31 = 3;
                    }
                    else 
                    {
                        if ( backtracking > 0 ) {failed = true; return ;}
                        NoViableAltException nvae_d31s2 =
                            new NoViableAltException("197:1: functionCall : (svc= ID '.' method= ID '(' count= functionArgs ')' | svc= ID '.' method= ID '()' | svc= ID '.' prop= ID );", 31, 2, input);
                    
                        throw nvae_d31s2;
                    }
                }
                else 
                {
                    if ( backtracking > 0 ) {failed = true; return ;}
                    NoViableAltException nvae_d31s1 =
                        new NoViableAltException("197:1: functionCall : (svc= ID '.' method= ID '(' count= functionArgs ')' | svc= ID '.' method= ID '()' | svc= ID '.' prop= ID );", 31, 1, input);
                
                    throw nvae_d31s1;
                }
            }
            else 
            {
                if ( backtracking > 0 ) {failed = true; return ;}
                NoViableAltException nvae_d31s0 =
                    new NoViableAltException("197:1: functionCall : (svc= ID '.' method= ID '(' count= functionArgs ')' | svc= ID '.' method= ID '()' | svc= ID '.' prop= ID );", 31, 0, input);
            
                throw nvae_d31s0;
            }
            switch (alt31) 
            {
                case 1 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:198:4: svc= ID '.' method= ID '(' count= functionArgs ')'
                    {
                    	svc = (IToken)input.LT(1);
                    	Match(input,ID,FOLLOW_ID_in_functionCall860); if (failed) return ;
                    	Match(input,65,FOLLOW_65_in_functionCall862); if (failed) return ;
                    	method = (IToken)input.LT(1);
                    	Match(input,ID,FOLLOW_ID_in_functionCall866); if (failed) return ;
                    	Match(input,LPAREN,FOLLOW_LPAREN_in_functionCall868); if (failed) return ;
                    	PushFollow(FOLLOW_functionArgs_in_functionCall872);
                    	count = functionArgs();
                    	followingStackPointer_--;
                    	if (failed) return ;
                    	Match(input,RPAREN,FOLLOW_RPAREN_in_functionCall874); if (failed) return ;
                    	if ( backtracking == 0 ) 
                    	{
                    	   Method( this, new TextFlowEventArgs( svc.Text, method.Text, count ) ); 
                    	}
                    
                    }
                    break;
                case 2 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:199:4: svc= ID '.' method= ID '()'
                    {
                    	svc = (IToken)input.LT(1);
                    	Match(input,ID,FOLLOW_ID_in_functionCall883); if (failed) return ;
                    	Match(input,65,FOLLOW_65_in_functionCall885); if (failed) return ;
                    	method = (IToken)input.LT(1);
                    	Match(input,ID,FOLLOW_ID_in_functionCall889); if (failed) return ;
                    	Match(input,66,FOLLOW_66_in_functionCall891); if (failed) return ;
                    	if ( backtracking == 0 ) 
                    	{
                    	   Method( this, new TextFlowEventArgs( svc.Text, method.Text, 0 ) ); 
                    	}
                    
                    }
                    break;
                case 3 :
                    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:200:4: svc= ID '.' prop= ID
                    {
                    	svc = (IToken)input.LT(1);
                    	Match(input,ID,FOLLOW_ID_in_functionCall903); if (failed) return ;
                    	Match(input,65,FOLLOW_65_in_functionCall905); if (failed) return ;
                    	prop = (IToken)input.LT(1);
                    	Match(input,ID,FOLLOW_ID_in_functionCall909); if (failed) return ;
                    	if ( backtracking == 0 ) 
                    	{
                    	   Property( this, new TextFlowEventArgs( svc.Text, prop.Text ) ); 
                    	}
                    
                    }
                    break;
            
            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 25, functionCall_StartIndex); 
            }
        }
        return ;
    }
    // $ANTLR end functionCall

    
    // $ANTLR start functionArgs
    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:203:1: functionArgs returns [ int argcount ] : expression ( ',' expression )* ;
    public int functionArgs() // throws RecognitionException [1]
    {   

        int argcount = 0;
        int functionArgs_StartIndex = input.Index();
         argcount =  0; 
        try 
    	{
    	    if ( (backtracking > 0) && AlreadyParsedRule(input, 26) ) 
    	    {
    	    	return argcount; 
    	    }
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:205:2: ( expression ( ',' expression )* )
            // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:205:4: expression ( ',' expression )*
            {
            	PushFollow(FOLLOW_expression_in_functionArgs936);
            	expression();
            	followingStackPointer_--;
            	if (failed) return argcount;
            	if ( backtracking == 0 ) 
            	{
            	   argcount += 1; 
            	}
            	// C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:205:34: ( ',' expression )*
            	do 
            	{
            	    int alt32 = 2;
            	    int LA32_0 = input.LA(1);
            	    
            	    if ( (LA32_0 == 67) )
            	    {
            	        alt32 = 1;
            	    }
            	    
            	
            	    switch (alt32) 
            		{
            			case 1 :
            			    // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:205:35: ',' expression
            			    {
            			    	Match(input,67,FOLLOW_67_in_functionArgs941); if (failed) return argcount;
            			    	PushFollow(FOLLOW_expression_in_functionArgs943);
            			    	expression();
            			    	followingStackPointer_--;
            			    	if (failed) return argcount;
            			    	if ( backtracking == 0 ) 
            			    	{
            			    	   argcount += 1; 
            			    	}
            			    
            			    }
            			    break;
            	
            			default:
            			    goto loop32;
            	    }
            	} while (true);
            	
            	loop32:
            		;	// Stops C# compiler whinging that label 'loop32' has no statements

            
            }
    
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            if ( backtracking > 0 ) 
            {
            	Memoize(input, 26, functionArgs_StartIndex); 
            }
        }
        return argcount;
    }
    // $ANTLR end functionArgs

    // $ANTLR start synpred52
    public void synpred52_fragment() //throws RecognitionException
    {   
        // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:198:4: ( ID '.' ID '(' functionArgs ')' )
        // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:198:4: ID '.' ID '(' functionArgs ')'
        {
        	Match(input,ID,FOLLOW_ID_in_synpred52860); if (failed) return ;
        	Match(input,65,FOLLOW_65_in_synpred52862); if (failed) return ;
        	Match(input,ID,FOLLOW_ID_in_synpred52866); if (failed) return ;
        	Match(input,LPAREN,FOLLOW_LPAREN_in_synpred52868); if (failed) return ;
        	PushFollow(FOLLOW_functionArgs_in_synpred52872);
        	functionArgs();
        	followingStackPointer_--;
        	if (failed) return ;
        	Match(input,RPAREN,FOLLOW_RPAREN_in_synpred52874); if (failed) return ;
        
        }
    }
    // $ANTLR end synpred52

    // $ANTLR start synpred53
    public void synpred53_fragment() //throws RecognitionException
    {   
        // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:199:4: ( ID '.' ID '()' )
        // C:\\CodePlex\\TextFlow\\Main\\TextFlow.Engine\\ANTLR\\TextFlowLang.g:199:4: ID '.' ID '()'
        {
        	Match(input,ID,FOLLOW_ID_in_synpred53883); if (failed) return ;
        	Match(input,65,FOLLOW_65_in_synpred53885); if (failed) return ;
        	Match(input,ID,FOLLOW_ID_in_synpred53889); if (failed) return ;
        	Match(input,66,FOLLOW_66_in_synpred53891); if (failed) return ;
        
        }
    }
    // $ANTLR end synpred53

   	public bool synpred53() 
   	{
   	    backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred53_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !failed;
   	    input.Rewind(start);
   	    backtracking--;
   	    failed = false;
   	    return success;
   	}
   	public bool synpred52() 
   	{
   	    backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred52_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !failed;
   	    input.Rewind(start);
   	    backtracking--;
   	    failed = false;
   	    return success;
   	}


	private void InitializeCyclicDFAs()
	{
	}

 

    public static readonly BitSet FOLLOW_stmt_in_prog56 = new BitSet(new ulong[]{0x000051424E8A0002UL});
    public static readonly BitSet FOLLOW_ifstmt_in_stmt73 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_whilestmt_in_stmt82 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_parallelstmt_in_stmt91 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_delaystmt_in_stmt100 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_errorstmt_in_stmt109 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_handleerrorstmt_in_stmt118 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_iterationstmt_in_stmt127 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_txnstmt_in_stmt136 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_stopstmt_in_stmt145 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_assignmentstmt_in_stmt150 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_actionstmt_in_stmt155 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_17_in_txnstmt167 = new BitSet(new ulong[]{0x000051424EAA0000UL});
    public static readonly BitSet FOLLOW_stmt_in_txnstmt172 = new BitSet(new ulong[]{0x000051424EAA0000UL});
    public static readonly BitSet FOLLOW_rollbackstmt_in_txnstmt176 = new BitSet(new ulong[]{0x0000000000040000UL});
    public static readonly BitSet FOLLOW_18_in_txnstmt178 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_19_in_txnstmt185 = new BitSet(new ulong[]{0x000051424EAA0000UL});
    public static readonly BitSet FOLLOW_stmt_in_txnstmt190 = new BitSet(new ulong[]{0x000051424EAA0000UL});
    public static readonly BitSet FOLLOW_rollbackstmt_in_txnstmt194 = new BitSet(new ulong[]{0x0000000000100000UL});
    public static readonly BitSet FOLLOW_20_in_txnstmt196 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_21_in_rollbackstmt210 = new BitSet(new ulong[]{0x000051424ECA0000UL});
    public static readonly BitSet FOLLOW_stmt_in_rollbackstmt215 = new BitSet(new ulong[]{0x000051424ECA0000UL});
    public static readonly BitSet FOLLOW_22_in_rollbackstmt219 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_23_in_handleerrorstmt233 = new BitSet(new ulong[]{0x000051424F8A0000UL});
    public static readonly BitSet FOLLOW_stmt_in_handleerrorstmt238 = new BitSet(new ulong[]{0x000051424F8A0000UL});
    public static readonly BitSet FOLLOW_24_in_handleerrorstmt242 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_25_in_stopstmt257 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_26_in_errorstmt273 = new BitSet(new ulong[]{0x0000000000000010UL});
    public static readonly BitSet FOLLOW_STRING_in_errorstmt275 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_27_in_delaystmt289 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_DECIMAL_in_delaystmt291 = new BitSet(new ulong[]{0x0000000030000000UL});
    public static readonly BitSet FOLLOW_28_in_delaystmt294 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_29_in_delaystmt300 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_30_in_iterationstmt317 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_DECIMAL_in_iterationstmt319 = new BitSet(new ulong[]{0x0000000080000000UL});
    public static readonly BitSet FOLLOW_31_in_iterationstmt321 = new BitSet(new ulong[]{0x000051434E8A0000UL});
    public static readonly BitSet FOLLOW_stmt_in_iterationstmt326 = new BitSet(new ulong[]{0x000051434E8A0000UL});
    public static readonly BitSet FOLLOW_32_in_iterationstmt330 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_33_in_ifstmt343 = new BitSet(new ulong[]{0x404E0000000003F0UL});
    public static readonly BitSet FOLLOW_expression_in_ifstmt347 = new BitSet(new ulong[]{0x0000000400000000UL});
    public static readonly BitSet FOLLOW_34_in_ifstmt351 = new BitSet(new ulong[]{0x0000517A4E8A0000UL});
    public static readonly BitSet FOLLOW_stmt_in_ifstmt354 = new BitSet(new ulong[]{0x0000517A4E8A0000UL});
    public static readonly BitSet FOLLOW_35_in_ifstmt362 = new BitSet(new ulong[]{0x404E0000000003F0UL});
    public static readonly BitSet FOLLOW_expression_in_ifstmt366 = new BitSet(new ulong[]{0x0000000400000000UL});
    public static readonly BitSet FOLLOW_34_in_ifstmt370 = new BitSet(new ulong[]{0x0000517A4E8A0000UL});
    public static readonly BitSet FOLLOW_stmt_in_ifstmt373 = new BitSet(new ulong[]{0x0000517A4E8A0000UL});
    public static readonly BitSet FOLLOW_36_in_ifstmt383 = new BitSet(new ulong[]{0x000051624E8A0000UL});
    public static readonly BitSet FOLLOW_stmt_in_ifstmt388 = new BitSet(new ulong[]{0x000051624E8A0000UL});
    public static readonly BitSet FOLLOW_37_in_ifstmt397 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_38_in_whilestmt411 = new BitSet(new ulong[]{0x404E0000000003F0UL});
    public static readonly BitSet FOLLOW_expression_in_whilestmt415 = new BitSet(new ulong[]{0x000051C24E8A0000UL});
    public static readonly BitSet FOLLOW_stmt_in_whilestmt420 = new BitSet(new ulong[]{0x000051C24E8A0000UL});
    public static readonly BitSet FOLLOW_39_in_whilestmt424 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_40_in_parallelstmt439 = new BitSet(new ulong[]{0x0000020000000000UL});
    public static readonly BitSet FOLLOW_41_in_parallelstmt450 = new BitSet(new ulong[]{0x000055424E8A0000UL});
    public static readonly BitSet FOLLOW_stmt_in_parallelstmt453 = new BitSet(new ulong[]{0x000055424E8A0000UL});
    public static readonly BitSet FOLLOW_42_in_parallelstmt457 = new BitSet(new ulong[]{0x00000A0000000000UL});
    public static readonly BitSet FOLLOW_43_in_parallelstmt467 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_44_in_assignmentstmt480 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_ID_in_assignmentstmt482 = new BitSet(new ulong[]{0x0000200000000000UL});
    public static readonly BitSet FOLLOW_45_in_assignmentstmt484 = new BitSet(new ulong[]{0x404E0000000003F0UL});
    public static readonly BitSet FOLLOW_expression_in_assignmentstmt486 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_46_in_actionstmt499 = new BitSet(new ulong[]{0x404E0000000003F0UL});
    public static readonly BitSet FOLLOW_actionInput_in_actionstmt501 = new BitSet(new ulong[]{0x404E0000000003F0UL});
    public static readonly BitSet FOLLOW_ID_in_actionstmt504 = new BitSet(new ulong[]{0x0000800000000040UL});
    public static readonly BitSet FOLLOW_actionOutput_in_actionstmt508 = new BitSet(new ulong[]{0x0000800000000040UL});
    public static readonly BitSet FOLLOW_47_in_actionstmt511 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_in_actionInput526 = new BitSet(new ulong[]{0x0001000000000000UL});
    public static readonly BitSet FOLLOW_48_in_actionInput528 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_ID_in_actionInput530 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ID_in_actionOutput547 = new BitSet(new ulong[]{0x0001000000000000UL});
    public static readonly BitSet FOLLOW_48_in_actionOutput549 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_ID_in_actionOutput553 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_DECIMAL_in_literal571 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_FLOAT_in_literal580 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CHAR_in_literal589 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_STRING_in_literal598 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_49_in_literal607 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_50_in_literal616 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_51_in_literal625 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_conditionalAndExpression_in_expression640 = new BitSet(new ulong[]{0x0010000000000002UL});
    public static readonly BitSet FOLLOW_52_in_expression644 = new BitSet(new ulong[]{0x404E0000000003F0UL});
    public static readonly BitSet FOLLOW_conditionalAndExpression_in_expression646 = new BitSet(new ulong[]{0x0010000000000002UL});
    public static readonly BitSet FOLLOW_conditionalNotExpression_in_conditionalAndExpression662 = new BitSet(new ulong[]{0x0020000000000002UL});
    public static readonly BitSet FOLLOW_53_in_conditionalAndExpression666 = new BitSet(new ulong[]{0x404E0000000003F0UL});
    public static readonly BitSet FOLLOW_conditionalNotExpression_in_conditionalAndExpression668 = new BitSet(new ulong[]{0x0020000000000002UL});
    public static readonly BitSet FOLLOW_54_in_conditionalNotExpression686 = new BitSet(new ulong[]{0x400E0000000003F0UL});
    public static readonly BitSet FOLLOW_equalityExpression_in_conditionalNotExpression693 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_additiveExpression_in_equalityExpression704 = new BitSet(new ulong[]{0x1F80000000000002UL});
    public static readonly BitSet FOLLOW_55_in_equalityExpression711 = new BitSet(new ulong[]{0x400E0000000003F0UL});
    public static readonly BitSet FOLLOW_56_in_equalityExpression715 = new BitSet(new ulong[]{0x400E0000000003F0UL});
    public static readonly BitSet FOLLOW_57_in_equalityExpression719 = new BitSet(new ulong[]{0x400E0000000003F0UL});
    public static readonly BitSet FOLLOW_58_in_equalityExpression723 = new BitSet(new ulong[]{0x400E0000000003F0UL});
    public static readonly BitSet FOLLOW_59_in_equalityExpression727 = new BitSet(new ulong[]{0x400E0000000003F0UL});
    public static readonly BitSet FOLLOW_60_in_equalityExpression731 = new BitSet(new ulong[]{0x400E0000000003F0UL});
    public static readonly BitSet FOLLOW_additiveExpression_in_equalityExpression734 = new BitSet(new ulong[]{0x1F80000000000002UL});
    public static readonly BitSet FOLLOW_multiplicativeExpression_in_additiveExpression750 = new BitSet(new ulong[]{0x6000000000000002UL});
    public static readonly BitSet FOLLOW_61_in_additiveExpression757 = new BitSet(new ulong[]{0x400E0000000003F0UL});
    public static readonly BitSet FOLLOW_62_in_additiveExpression761 = new BitSet(new ulong[]{0x400E0000000003F0UL});
    public static readonly BitSet FOLLOW_multiplicativeExpression_in_additiveExpression764 = new BitSet(new ulong[]{0x6000000000000002UL});
    public static readonly BitSet FOLLOW_unaryExpression_in_multiplicativeExpression780 = new BitSet(new ulong[]{0x8000000000000002UL,0x0000000000000001UL});
    public static readonly BitSet FOLLOW_63_in_multiplicativeExpression787 = new BitSet(new ulong[]{0x400E0000000003F0UL});
    public static readonly BitSet FOLLOW_64_in_multiplicativeExpression791 = new BitSet(new ulong[]{0x400E0000000003F0UL});
    public static readonly BitSet FOLLOW_unaryExpression_in_multiplicativeExpression794 = new BitSet(new ulong[]{0x8000000000000002UL,0x0000000000000001UL});
    public static readonly BitSet FOLLOW_62_in_unaryExpression811 = new BitSet(new ulong[]{0x400E0000000003F0UL});
    public static readonly BitSet FOLLOW_unaryExpression_in_unaryExpression813 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_LPAREN_in_unaryExpression822 = new BitSet(new ulong[]{0x404E0000000003F0UL});
    public static readonly BitSet FOLLOW_expression_in_unaryExpression824 = new BitSet(new ulong[]{0x0000000000000400UL});
    public static readonly BitSet FOLLOW_RPAREN_in_unaryExpression826 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_functionCall_in_unaryExpression831 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_literal_in_unaryExpression836 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ID_in_unaryExpression841 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ID_in_functionCall860 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000002UL});
    public static readonly BitSet FOLLOW_65_in_functionCall862 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_ID_in_functionCall866 = new BitSet(new ulong[]{0x0000000000000200UL});
    public static readonly BitSet FOLLOW_LPAREN_in_functionCall868 = new BitSet(new ulong[]{0x404E0000000003F0UL});
    public static readonly BitSet FOLLOW_functionArgs_in_functionCall872 = new BitSet(new ulong[]{0x0000000000000400UL});
    public static readonly BitSet FOLLOW_RPAREN_in_functionCall874 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ID_in_functionCall883 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000002UL});
    public static readonly BitSet FOLLOW_65_in_functionCall885 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_ID_in_functionCall889 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000004UL});
    public static readonly BitSet FOLLOW_66_in_functionCall891 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ID_in_functionCall903 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000002UL});
    public static readonly BitSet FOLLOW_65_in_functionCall905 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_ID_in_functionCall909 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_in_functionArgs936 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000008UL});
    public static readonly BitSet FOLLOW_67_in_functionArgs941 = new BitSet(new ulong[]{0x404E0000000003F0UL});
    public static readonly BitSet FOLLOW_expression_in_functionArgs943 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000008UL});
    public static readonly BitSet FOLLOW_ID_in_synpred52860 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000002UL});
    public static readonly BitSet FOLLOW_65_in_synpred52862 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_ID_in_synpred52866 = new BitSet(new ulong[]{0x0000000000000200UL});
    public static readonly BitSet FOLLOW_LPAREN_in_synpred52868 = new BitSet(new ulong[]{0x404E0000000003F0UL});
    public static readonly BitSet FOLLOW_functionArgs_in_synpred52872 = new BitSet(new ulong[]{0x0000000000000400UL});
    public static readonly BitSet FOLLOW_RPAREN_in_synpred52874 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ID_in_synpred53883 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000002UL});
    public static readonly BitSet FOLLOW_65_in_synpred53885 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_ID_in_synpred53889 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000004UL});
    public static readonly BitSet FOLLOW_66_in_synpred53891 = new BitSet(new ulong[]{0x0000000000000002UL});

}
